package com.shlh.saas.service;

import com.shlh.saas.entity.facebook.FacebookUser;
import com.shlh.saas.entity.twitter.TwitterUserEs;
import com.shlh.saas.model.dto.TwitterQueryDTO;
import com.shlh.saas.service.company.CompanyService;
import com.shlh.saas.service.facebook.FacebookEsService;
import com.shlh.saas.service.facebook.FacebookUserService;
import com.shlh.saas.service.linkedin.LinkedInUserService;
import com.shlh.saas.service.twitter.TwitterService;
import jakarta.annotation.Resource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;

import java.util.*;

/**
 * 邮箱和电话反向查询服务
 * 支持查询所有包含邮箱或电话字段的数据表
 */
@Service
public class EmailLookupService {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Resource
    private FacebookUserService facebookUserService;

    @Resource
    private LinkedInUserService linkedInUserService;

    @Resource
    private CompanyService companyService;

    @Resource
    private TwitterService twitterService;

    /**
     * 根据邮箱或电话进行反向查询
     * @param value 邮箱地址或电话号码
     * @param type 查询类型 (email/phone)
     * @param page 页码
     * @param size 每页记录数
     * @return 查询结果和统计信息
     */
    public Map<String, Object> lookupByValue(String value, String type, int page, int size) {
        // 计算分页参数
        int offset = (page - 1) * size;

        // 精确匹配而不是模糊匹配
        String exactValue = value;
        
        // 存储所有查询结果
        List<Map<String, Object>> allResults = new ArrayList<>();
        long total = 0;
        
        // 是否跳过有问题的表
        final boolean skipFacebook = false; // 设置为true可以跳过Facebook查询
        final boolean skipTwitter = false;  // 根据用户反馈，Twitter表有email字段，启用查询
        
        try {
            System.out.println("开始按顺序查询所有数据库...");
            
            // 1. 搜索广交会展商表 - 跳过（已知有问题）
            System.out.println("广交会展商数据：由于表结构问题跳过查询");
            
            // 2. 搜索广交会采购商表
            try {
                System.out.println("开始查询广交会采购商数据...");
                List<Map<String, Object>> buyersResults = searchCantonFairBuyers(exactValue, type, size, offset);
                if (!buyersResults.isEmpty()) {
                    System.out.println("广交会采购商数据找到匹配记录: " + buyersResults.size() + " 条");
                    allResults.addAll(buyersResults);
                    total += countCantonFairBuyers(exactValue, type);
                } else {
                    System.out.println("广交会采购商数据未找到匹配记录");
                }
            } catch (Exception e) {
                System.err.println("广交会采购商数据查询失败: " + e.getMessage());
            }
            
            // 3. 搜索Facebook数据
            if (!skipFacebook) {
                try {
                    System.out.println("开始查询Facebook数据...");
                    List<Map<String, Object>> facebookResults = searchFacebook(exactValue, type, size, offset);
                    if (!facebookResults.isEmpty()) {
                        System.out.println("Facebook数据找到匹配记录: " + facebookResults.size() + " 条");
                        allResults.addAll(facebookResults);
                        total += countFacebook(exactValue, type);
                    } else {
                        System.out.println("Facebook数据未找到匹配记录");
                    }
                } catch (Exception e) {
                    System.err.println("Facebook数据查询失败: " + e.getMessage());
                }
            } else {
                System.out.println("Facebook数据：已配置为跳过查询");
            }
            
            // 4. 搜索全球企业库
            try {
                System.out.println("开始查询企业库数据...");
                List<Map<String, Object>> enterpriseResults = searchEnterprise(exactValue, type, size, offset);
                if (!enterpriseResults.isEmpty()) {
                    System.out.println("企业库数据找到匹配记录: " + enterpriseResults.size() + " 条");
                    allResults.addAll(enterpriseResults);
                    total += countEnterprise(exactValue, type);
                } else {
                    System.out.println("企业库数据未找到匹配记录");
                }
            } catch (Exception e) {
                System.err.println("企业库数据查询失败: " + e.getMessage());
            }

            // 5. 搜索LinkedIn数据
            try {
                System.out.println("开始查询LinkedIn数据...");
                List<Map<String, Object>> linkedinResults = searchLinkedIn(exactValue, type, size, offset);
                if (!linkedinResults.isEmpty()) {
                    System.out.println("LinkedIn数据找到匹配记录: " + linkedinResults.size() + " 条");
                    allResults.addAll(linkedinResults);
                    total += countLinkedIn(exactValue, type);
                } else {
                    System.out.println("LinkedIn数据未找到匹配记录");
                }
            } catch (Exception e) {
                System.err.println("LinkedIn数据查询失败: " + e.getMessage());
            }

            // 6. 搜索Twitter数据
            if (!skipTwitter) {
                try {
                    System.out.println("开始查询Twitter数据...");
                    List<Map<String, Object>> twitterResults = searchTwitter(exactValue, type, size, offset);
                    if (!twitterResults.isEmpty()) {
                        System.out.println("Twitter数据找到匹配记录: " + twitterResults.size() + " 条");
                        allResults.addAll(twitterResults);
                        total += countTwitter(exactValue, type);
                    } else {
                        System.out.println("Twitter数据未找到匹配记录");
                    }
                } catch (Exception e) {
                    System.err.println("Twitter数据查询失败: " + e.getMessage());
                }
            } else {
                System.out.println("Twitter数据：由于表结构问题跳过查询");
            }
            
            // 7. 搜索海关数据
//            if (type.equals("phone")) {  // 海关数据只支持电话查询
//                try {
//                    System.out.println("开始查询海关数据...");
//                    List<Map<String, Object>> customsResults = searchCustoms(exactValue, size, offset);
//                    if (!customsResults.isEmpty()) {
//                        System.out.println("海关数据找到匹配记录: " + customsResults.size() + " 条");
//                        allResults.addAll(customsResults);
//                        total += countCustoms(exactValue);
//                    } else {
//                        System.out.println("海关数据未找到匹配记录");
//                    }
//                } catch (Exception e) {
//                    System.err.println("海关数据查询失败: " + e.getMessage());
//                }
//            } else {
//                System.out.println("海关数据：表中不存在email字段，跳过查询");
//            }

            System.out.println("所有数据库查询完成，总共找到: " + total + " 条记录");
            
        } catch (Exception e) {
            System.err.println("查询过程中发生错误: " + e.getMessage());
            e.printStackTrace();
            
            // 发生异常时返回有错误信息的结果
            Map<String, Object> errorResponse = new HashMap<>();
            errorResponse.put("results", allResults); // 返回已经收集到的结果
            errorResponse.put("total", total);        // 返回已经计算的总数
            errorResponse.put("page", page);
            errorResponse.put("size", size);
            errorResponse.put("error", "查询过程中发生错误: " + e.getMessage());
            return errorResponse;
        }

        // 返回结果
        Map<String, Object> response = new HashMap<>();
        response.put("results", allResults);
        response.put("total", total);
        response.put("page", page);
        response.put("size", size);
        
        return response;
    }
    
    /**
     * 查询广交会采购商数据
     */
    private List<Map<String, Object>> searchCantonFairBuyers(String value, String type, int size, int offset) {
        try {
            if (type.equals("email")) {
                String sql = "SELECT * FROM canton_fair_buyers WHERE email = ? LIMIT ? OFFSET ?";
                List<Map<String, Object>> results = jdbcTemplate.queryForList(sql, value, size, offset);
                final String source = "canton_fair_buyers";
                results.forEach(map -> map.put("source", source));
                return results;
            } else {
                String sql = "SELECT * FROM canton_fair_buyers WHERE phone = ? LIMIT ? OFFSET ?";
                List<Map<String, Object>> results = jdbcTemplate.queryForList(sql, value, size, offset);
                final String source = "canton_fair_buyers";
                results.forEach(map -> map.put("source", source));
                return results;
            }
        } catch (Exception e) {
            System.err.println("广交会采购商数据查询失败: " + e.getMessage());
            return new ArrayList<>();
        }
    }
    
    /**
     * 计算广交会采购商数据数量
     */
    private int countCantonFairBuyers(String value, String type) {
        try {
            if (type.equals("email")) {
                String sql = "SELECT COUNT(*) FROM canton_fair_buyers WHERE email = ?";
                Integer count = jdbcTemplate.queryForObject(sql, Integer.class, value);
                return count != null ? count : 0;
            } else {
                String sql = "SELECT COUNT(*) FROM canton_fair_buyers WHERE phone = ?";
                Integer count = jdbcTemplate.queryForObject(sql, Integer.class, value);
                return count != null ? count : 0;
            }
        } catch (Exception e) {
            System.err.println("广交会采购商数据计数查询失败: " + e.getMessage());
            return 0;
        }
    }
    
    /**
     * 查询Facebook数据
     */
    private List<Map<String, Object>> searchFacebook(String value, String type, int size, int offset) {
        final List<Map<String, Object>> allResults = new ArrayList<>();
        try {

            if (type.equals("email")) {
                List<Map<String, Object>> fbUsersResults = facebookUserService.searchByEmail(value, size, offset);
                final String sourcePrefix = "facebook_data";
                fbUsersResults.forEach(map -> map.put("source", sourcePrefix));
                allResults.addAll(fbUsersResults);
            } else {
                List<Map<String, Object>> fbUsersResults = facebookUserService.searchByPhone(value, size, offset);
                final String sourcePrefix = "facebook_data";
                fbUsersResults.forEach(map -> map.put("source", sourcePrefix));
                allResults.addAll(fbUsersResults);
            }

            System.out.println("Facebook数据查询完成，总共找到: " + allResults.size() + " 条记录");

            // 应用分页
            final int startIndex = offset > allResults.size() ? allResults.size() : offset;
            final int endIndex = Math.min(startIndex + size, allResults.size());

            if (startIndex < endIndex) {
                return allResults.subList(startIndex, endIndex);
            }

            return new ArrayList<>();
        }
        catch (Exception e) {
            System.err.println("Facebook数据查询失败: " + e.getMessage());
            e.printStackTrace();
            return new ArrayList<>();
        }
    }
    
    /**
     * 计算Facebook数据数量
     */
    private long countFacebook(String value, String type) {
        long totalCount;
        
        try {
            if (type.equals("email")) {

                totalCount = facebookUserService.countByEmail(value);

                return totalCount;
            }else {
                totalCount = facebookUserService.countByPhone(value);

                return totalCount;
            }
        } catch (Exception e) {
            System.err.println("Facebook数据计数查询失败: " + e.getMessage());
            return 0;
        }
    }
    
    /**
     * 查询全球企业库数据
     */
    private List<Map<String, Object>> searchEnterprise(String value, String type, int size, int offset) {
        final List<Map<String, Object>> allResults = new ArrayList<>();
        
        try {
            if (type.equals("email")) {
                List<Map<String, Object>> companyResults = companyService.searchByEmail(value, size, offset);
                final String sourcePrefix = "";
                companyResults.forEach(map -> map.put("source", sourcePrefix));
                allResults.addAll(companyResults);
            } else {
                List<Map<String, Object>> companyResults = companyService.searchByPhone(value, size, offset);
                final String sourcePrefix = "";
                companyResults.forEach(map -> map.put("source", sourcePrefix));
                allResults.addAll(companyResults);
            }

            System.out.println("企业库数据查询完成，总共找到: " + allResults.size() + " 条记录");

            // 应用分页
            final int startIndex = offset > allResults.size() ? allResults.size() : offset;
            final int endIndex = Math.min(startIndex + size, allResults.size());

            if (startIndex < endIndex) {
                return allResults.subList(startIndex, endIndex);
            }

            return new ArrayList<>();
        } catch (Exception e) {
            System.err.println("企业库数据查询失败: " + e.getMessage());
            e.printStackTrace();
            return new ArrayList<>();
        }
    }
    
    /**
     * 计算全球企业库数据数量
     */
    private long countEnterprise(String value, String type) {
        long totalCount;
        
        try {
            if (type.equals("email")) {

                totalCount = companyService.countByEmail(value);

                return totalCount;
            }else {
                totalCount = companyService.countByPhone(value);

                return totalCount;
            }
        } catch (Exception e) {
            System.err.println("企业库数据计数查询失败: " + e.getMessage());
            return 0;
        }
    }
    
    /**
     * 查询LinkedIn数据
     */
    private List<Map<String, Object>> searchLinkedIn(String value, String type, int size, int offset) {
        try {
            if (type.equals("email")) {
                List<Map<String, Object>> results = linkedInUserService.searchByEmail(value, size, offset);
                final String source = "ly_user";
                results.forEach(map -> map.put("source", source));
                return results;
            } else {
                List<Map<String, Object>> results = linkedInUserService.searchByPhone(value, size, offset);
                final String source = "ly_user";
                results.forEach(map -> map.put("source", source));
                return results;
            }
        } catch (Exception e) {
            System.err.println("LinkedIn数据查询失败: " + e.getMessage());
            return new ArrayList<>();
        }
    }
    
    /**
     * 计算LinkedIn数据数量
     */
    private long countLinkedIn(String value, String type) {
        try {
            if (type.equals("email")) {
                Long count = linkedInUserService.countWithEmail(value);
                return count != null ? count : 0;
            } else {
                Long count = linkedInUserService.countWithPhone(value);
                return count != null ? count : 0;
            }
        } catch (Exception e) {
            System.err.println("LinkedIn数据计数查询失败: " + e.getMessage());
            return 0;
        }
    }
    
    /**
     * 查询海关数据
     */
//    private List<Map<String, Object>> searchCustoms(String value, int size, int offset) {
//        final List<Map<String, Object>> allResults = new ArrayList<>();
//
//        try {
//            final int totalShards = 200; // 完整查询海关分片表
//            System.out.println("查询海关数据，分片范围: 0-" + (totalShards-1));
//
//            // 尝试不同的表名格式
//            final String[] tableNamePatterns = {
//                "customs_trade_%d",        // customs_trade_0, customs_trade_1, ...
//                "customs_%d",              // customs_0, customs_1, ...
//                "custom_trade_%d",         // custom_trade_0, custom_trade_1, ...
//                "custom_%d"                // custom_0, custom_1, ...
//            };
//
//            boolean foundValidTablePattern = false;
//
//            // 首先尝试每种表名模式的第一个表，找到有效的表名模式
//            for (String pattern : tableNamePatterns) {
//                final String tableName = String.format(pattern, 0); // 尝试第0个分片
//                final String testSql = "SELECT 1 FROM " + tableName + " LIMIT 1";
//
//                try {
//                    jdbcTemplate.queryForObject(testSql, Integer.class);
//                    // 如果没有抛出异常，说明表存在
//                    foundValidTablePattern = true;
//                    System.out.println("找到有效的海关表名模式: " + pattern);
//
//                    // 使用找到的有效表名模式查询所有分片
//                    for (int i = 0; i < totalShards; i++) {
//                        final int shardIndex = i; // 创建final副本用于Lambda表达式
//                        final String shardTableName = String.format(pattern, shardIndex);
//
//                        try {
//                            // 海关数据表可能有多个电话字段，尝试查询所有可能字段
//                            String sql = "SELECT * FROM " + shardTableName +
//                                    " WHERE phone = ? OR telephone = ? OR mobile = ? LIMIT ?";
//                            List<Map<String, Object>> results =
//                                jdbcTemplate.queryForList(sql, value, value, value, size);
//
//                            if (results != null && !results.isEmpty()) {
//                                System.out.println("海关分片 " + shardIndex + " 找到匹配数据: " + results.size() + " 条");
//                                final String sourcePrefix = "customs_" + shardIndex;
//                                results.forEach(map -> map.put("source", sourcePrefix));
//                                allResults.addAll(results);
//                            }
//                        } catch (Exception e) {
//                            // 忽略表不存在错误或其他查询错误
//                            // 可能部分分片表不存在，这是正常的
//                            if (e.getMessage() != null &&
//                                !e.getMessage().contains("doesn't exist") &&
//                                !e.getMessage().contains("bad SQL grammar") &&
//                                !e.getMessage().contains("Unknown column")) {
//                                System.err.println("查询" + shardTableName + "时发生错误: " + e.getMessage());
//                            }
//                        }
//                    }
//
//                    // 找到有效模式后，跳出循环不再尝试其他模式
//                    break;
//                } catch (Exception e) {
//                    // 表可能不存在，继续尝试下一个模式
//                    System.out.println("表名模式 " + pattern + " 无效，尝试下一个");
//                }
//            }
//
//            // 如果没有找到有效的表名模式，尝试直接查询非分片表
//            if (!foundValidTablePattern) {
//                System.out.println("未找到有效的海关分片表模式，尝试查询单一表");
//
//                final String[] singleTableNames = {
//                    "customs_trade",
//                    "customs",
//                    "custom_trade",
//                    "custom"
//                };
//
//                for (String tableName : singleTableNames) {
//                    try {
//                        String sql = "SELECT * FROM " + tableName +
//                                " WHERE phone = ? OR telephone = ? OR mobile = ? LIMIT ? OFFSET ?";
//                        List<Map<String, Object>> results =
//                            jdbcTemplate.queryForList(sql, value, value, value, size, offset);
//
//                        if (results != null && !results.isEmpty()) {
//                            System.out.println(tableName + " 找到匹配数据: " + results.size() + " 条");
//                            final String source = tableName;
//                            results.forEach(map -> map.put("source", source));
//                            allResults.addAll(results);
//                            break; // 找到有效表后退出循环
//                        }
//                    } catch (Exception e) {
//                        // 表可能不存在，继续尝试下一个
//                        if (e.getMessage() != null &&
//                            !e.getMessage().contains("doesn't exist") &&
//                            !e.getMessage().contains("bad SQL grammar") &&
//                            !e.getMessage().contains("Unknown column")) {
//                            System.err.println("查询" + tableName + "时发生错误: " + e.getMessage());
//                        }
//                    }
//                }
//            }
//
//            System.out.println("海关数据查询完成，总共找到: " + allResults.size() + " 条记录");
//
//            // 应用分页
//            final int startIndex = offset > allResults.size() ? allResults.size() : offset;
//            final int endIndex = Math.min(startIndex + size, allResults.size());
//
//            if (startIndex < endIndex) {
//                return allResults.subList(startIndex, endIndex);
//            }
//
//            return new ArrayList<>();
//        } catch (Exception e) {
//            System.err.println("海关数据查询失败: " + e.getMessage());
//            e.printStackTrace();
//            return new ArrayList<>();
//        }
//    }
    
    /**
     * 计算海关数据数量
     */
//    private int countCustoms(String value) {
//        int totalCount = 0;
//
//        try {
//            final int totalShards = 200;
//
//            // 尝试不同的表名格式
//            final String[] tableNamePatterns = {
//                "customs_trade_%d",
//                "customs_%d",
//                "custom_trade_%d",
//                "custom_%d"
//            };
//
//            boolean foundValidTablePattern = false;
//
//            // 首先尝试每种表名模式的第一个表，找到有效的表名模式
//            for (String pattern : tableNamePatterns) {
//                final String tableName = String.format(pattern, 0); // 尝试第0个分片
//                final String testSql = "SELECT 1 FROM " + tableName + " LIMIT 1";
//
//                try {
//                    jdbcTemplate.queryForObject(testSql, Integer.class);
//                    // 如果没有抛出异常，说明表存在
//                    foundValidTablePattern = true;
//
//                    // 使用找到的有效表名模式计数所有分片
//                    for (int i = 0; i < totalShards; i++) {
//                        final String shardTableName = String.format(pattern, i);
//
//                        try {
//                            String sql = "SELECT COUNT(*) FROM " + shardTableName +
//                                    " WHERE phone = ? OR telephone = ? OR mobile = ?";
//                            Integer count = jdbcTemplate.queryForObject(sql, Integer.class, value, value, value);
//                            totalCount += count != null ? count : 0;
//                        } catch (Exception e) {
//                            // 忽略表不存在错误或其他查询错误
//                        }
//                    }
//
//                    // 找到有效模式后，跳出循环不再尝试其他模式
//                    break;
//                } catch (Exception e) {
//                    // 表可能不存在，继续尝试下一个模式
//                }
//            }
//
//            // 如果没有找到有效的表名模式，尝试直接查询非分片表
//            if (!foundValidTablePattern) {
//                final String[] singleTableNames = {
//                    "customs_trade",
//                    "customs",
//                    "custom_trade",
//                    "custom"
//                };
//
//                for (String tableName : singleTableNames) {
//                    try {
//                        String sql = "SELECT COUNT(*) FROM " + tableName +
//                                " WHERE phone = ? OR telephone = ? OR mobile = ?";
//                        Integer count = jdbcTemplate.queryForObject(sql, Integer.class, value, value, value);
//                        if (count != null) {
//                            totalCount = count;
//                            break; // 找到有效表后退出循环
//                        }
//                    } catch (Exception e) {
//                        // 表可能不存在，继续尝试下一个
//                    }
//                }
//            }
//
//            return totalCount;
//        } catch (Exception e) {
//            System.err.println("海关数据计数查询失败: " + e.getMessage());
//            return 0;
//        }
//    }

    /**
     * 查询Twitter数据
     */
    private List<Map<String, Object>> searchTwitter(String value, String type, int size, int offset) {
        final List<Map<String, Object>> allResults = new ArrayList<>();
        
        try {
            if (type.equals("email")) {
                List<Map<String, Object>> results = twitterService.searchByEmail(value, size, offset);
                final String source = "twitter_user";
                results.forEach(map -> map.put("source", source));
                allResults.addAll(results);
            }

            System.out.println("Twitter数据查询完成，总共找到: " + allResults.size() + " 条记录");

            // 应用分页
            final int startIndex = offset > allResults.size() ? allResults.size() : offset;
            final int endIndex = Math.min(startIndex + size, allResults.size());

            if (startIndex < endIndex) {
                return allResults.subList(startIndex, endIndex);
            }

            return new ArrayList<>();
        } catch (Exception e) {
            System.err.println("Twitter数据查询失败: " + e.getMessage());
            e.printStackTrace();
            return new ArrayList<>();
        }
    }
    
    /**
     * 计算Twitter数据数量
     */
    private long countTwitter(String value, String type) {
        long totalCount = 0;
        
        try {
            if (type.equals("email")) {
                TwitterQueryDTO twitterQueryDTO = new TwitterQueryDTO();
                twitterQueryDTO.setEmail(value);
                totalCount = twitterService.countTwitterUsers(twitterQueryDTO);
            }

            return totalCount;
        } catch (Exception e) {
            System.err.println("Twitter数据计数查询失败: " + e.getMessage());
            return 0;
        }
    }

    /**
     * 查询ly_user表数据
     */
    private List<Map<String, Object>> searchLyUser(String value, int size, int offset) {
        try {
            String sql = "SELECT * FROM ly_user WHERE mobile = ? LIMIT ? OFFSET ?";
            List<Map<String, Object>> results = jdbcTemplate.queryForList(sql, value, size, offset);
            final String source = "ly_user";
            
            // 格式化返回结果
            results.forEach(map -> {
                map.put("source", source);
                // 确保关键字段存在，方便前端统一处理
                if (!map.containsKey("name") && map.containsKey("username")) {
                    map.put("name", map.get("username"));
                }
                if (!map.containsKey("phone") && map.containsKey("mobile")) {
                    map.put("phone", map.get("mobile"));
                }
            });
            
            return results;
        } catch (Exception e) {
            System.err.println("ly_user表查询失败: " + e.getMessage());
            return new ArrayList<>();
        }
    }
    
    /**
     * 计算ly_user表数据数量
     */
    private int countLyUser(String value) {
        try {
            String sql = "SELECT COUNT(*) FROM ly_user WHERE mobile = ?";
            Integer count = jdbcTemplate.queryForObject(sql, Integer.class, value);
            return count != null ? count : 0;
        } catch (Exception e) {
            System.err.println("ly_user表计数查询失败: " + e.getMessage());
            return 0;
        }
    }
    
    /**
     * 将FacebookUser对象转换为Map
     */
    private Map<String, Object> convertFacebookUserToMap(FacebookUser user) {
        Map<String, Object> result = new HashMap<>();
        result.put("id", user.getId());
        
        // 组合firstName和lastName作为完整姓名
        String fullName = "";
        if (user.getFirstName() != null && !user.getFirstName().isEmpty()) {
            fullName += user.getFirstName();
        }
        if (user.getLastName() != null && !user.getLastName().isEmpty()) {
            if (!fullName.isEmpty()) {
                fullName += " ";
            }
            fullName += user.getLastName();
        }
        result.put("name", fullName);
        
        result.put("email", user.getEmail());
        result.put("phone", user.getPhoneNumber());
        
        // 组合currentLocation和hometown作为位置信息
        String location = "";
        if (user.getCurrentLocation() != null && !user.getCurrentLocation().isEmpty()) {
            location = user.getCurrentLocation();
        } else if (user.getHometown() != null && !user.getHometown().isEmpty()) {
            location = user.getHometown();
        }
        result.put("location", location);
        
        result.put("gender", user.getGender());
        result.put("facebook_id", user.getFacebookId());
        result.put("workplace", user.getWorkplace());
        result.put("relationship_status", user.getRelationshipStatus());
        result.put("mysqlId", user.getId());
        result.put("mysqlTable", user.getMysqlTable());
        
        return result;
    }
} 